const util = require('util');
const path = require('path');

//1)promisify
//node api 所有的方法都是基于回调 第一个参数永远是err
// const fs = require('fs').promises; //fs模块里有个属性叫promises，会将所有方法都promisify
/*
fs.readFile(path.resolve(__dirname, '1.txt'), 'utf8').then(data => {
  console.log(data);
});
*/

//↕等价
const fs = require('fs');
/*
let read = util.promisify(fs.readFile);
read(path.resolve(__dirname, '1.txt'), 'utf8').then(data => {
  console.log(data);
});
*/


//---promisify/promisifyAll原理
const promisify = (fn) => (...args) => {
  return new Promise((resolve, reject) => {
    fn(...args, (err,data) => {
      if(err) return reject(err);
      resolve(data);
    });
  });
};

(async ()=>{
  let r = await promisify(fs.readFile)(path.resolve(__dirname,'1.txt'),'utf8')
  console.log(r);
})();

// const fs = require('fs').promises; //fs模块里有个属性叫promises，会将所有方法都promisify
/*
const promisifyAll = (obj) => {
  for (let key in obj) {
    obj[key] = promisify(obj[key]);
  }
};
promisifyAll(fs);
*/







//2)inherit
// 继承 继承公有属性 原型上的属性
function Parent(){
  this.type = 'parent';
}
Parent.prototype.say = function(){
  console.log('parent say')
}
function Child(){

}
// Object.setPrototypeOf(Child.prototype,Parent.prototype);
/*
var sub = {a : 1};
var super = {b : 1};
Object.setPrototypeOf(sub, super);  //sub.__proto__ = super
*/
util.inherits(Child,Parent);
let child = new Child();
child.say();



//3) util.format
//如果占位符没有相对应的参数，占位符将不会被替换。
util.format('%s:%s', 'foo'); // 'foo:%s'

//如果有多个参数占位符，额外的参数将会调用util.inspect()转换为字符串。这些字符串被连接在一起，并且以空格分隔。
util.format('%s:%s', 'foo', 'bar', 'baz'); // 'foo:bar baz'

//如果第一个参数是一个非格式化字符串，那么util.format()将会把所有的参数转成字符串，以空格隔开，拼接在一块，并返回该字符串。util.inspect()会把每个参数都转成一个字符串。
util.format(1, 2, 3); // '1 2 3'
